# @title 2.1&nbsp;Imports
from nltk.corpus import stopwords
from wordcloud import WordCloud

import matplotlib.pyplot as plt
import plotly.express as px
import pandas as pd
import numpy as np
import os
import csv
import json
import nltk
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay
from sklearn.utils.multiclass import unique_labels

# Codigo para que la parte interactiva se vea en el HTML

import plotly.io as pio
pio.renderers.default='notebook'

# @title 2.2&nbsp;Exportación de Drive
from google.colab import drive
drive.mount('/content/drive')

Mounted at /content/drive

# @title 2.3&nbsp;Carga de DataFrames
df_games = pd.read_csv('/content/drive/MyDrive/CC5205/games.csv', encoding="UTF-8")
df_steam_reviews = pd.read_csv('/content/drive/MyDrive/CC5205/steam_reviews.csv', encoding="UTF-8", nrows=12043389)

# @title 2.4&nbsp; WordCloud

# Asegurarse de que la columna 'release_date' esté en formato de fecha
df_games['release_date'] = pd.to_datetime(df_games['release_date'], errors='coerce')

# Extraer el año de la fecha de lanzamiento
df_games['year'] = df_games['release_date'].dt.year

# Filtrar los datos para eliminar aquellos sin año de lanzamiento válido
df_games = df_games.dropna(subset=['year'])

# Obtener los años únicos y ordenarlos
years = sorted(df_games['year'].unique())

# Crear una nube de palabras para cada año
for year in years:
    # Filtrar los juegos por año
    juegos_ano = df_games[df_games['year'] == year]

    # Crear un diccionario para contar las frecuencias de cada género
    genero_frecuencias = {}

    # Contar las frecuencias de cada género
    for generos in juegos_ano['genres']:
        if pd.notna(generos):  # Verificar que no sea NaN
            for genero in generos.split(','):
                genero = genero.strip()  # Quitar espacios en blanco alrededor
                if genero in genero_frecuencias:
                    genero_frecuencias[genero] += 1
                else:
                    genero_frecuencias[genero] = 1

    # Generar la nube de palabras usando las frecuencias
    wordcloud = WordCloud(width=800, height=400, background_color='white').generate_from_frequencies(genero_frecuencias)

    # Mostrar la nube de palabras
    plt.figure(figsize=(10, 5))
    plt.imshow(wordcloud, interpolation='bilinear')
    plt.title(f'Nube de Palabras de Géneros para el Año {int(year)}')
    plt.axis('off')  # Desactivar los ejes
    plt.show()

# @title 2.5&nbsp;Diagrama de Dispersión
# Crear el scatter plot
fig_scatter = px.scatter(df_games,
                         x='price',
                         y='recommendations',
                         color='metacritic_score',
                         title='Scatter Plot: Precio vs Número Total de Reseñas',
                         labels={'price': 'Precio (USD)', 'recommendations': 'Número Total de Recomendaciones'})

fig_scatter.show()

# @title 2.6&nbsp;Diagrama de Dispersión con límites

# Crear el scatter plot
fig_scatter = px.scatter(df_games,
                         x='price',
                         y='recommendations',
                         color='metacritic_score',
                         title='Scatter Plot: Precio vs Número Total de Reseñas',
                         labels={'price': 'Precio (USD)', 'recommendations': 'Número Total de Recomendaciones'},
                         range_x=[0,100],
                         range_y=[1,1000000])

fig_scatter.show()

# @title 2.7&nbsp;Histograma de tiempo de juego por rango de precios

# Agrupa los datos por rango de precios
price_bins = [0, 10, 20, 30, 40, 50, 60, 70, 80]
df_games['price_range'] = pd.cut(df_games['price'], bins=price_bins)

# Calcula la media del tiempo de juego promedio para cada rango de precios
games_price_range = df_games.groupby('price_range')['average_playtime_forever'].mean().reset_index()

# Convierte el tiempo de juego de minutos a horas
games_price_range['average_playtime_forever'] = games_price_range['average_playtime_forever'] / 60

# Convierte los intervalos a cadenas
games_price_range['price_range'] = games_price_range['price_range'].astype(str)

# Crea el histograma
fig = px.bar(games_price_range, x='price_range', y='average_playtime_forever',
             title='Promedio de tiempo de juego por rango de precios',
             labels={'price_range': 'Rango de precios', 'average_playtime_forever': 'Promedio de tiempo de juego (horas)'},
             color_discrete_sequence=['orange'])

# Muestra el histograma
fig.show()

# @title 2.7&nbsp;WordCloud sobre palabras presentes en reseñas de juegos del género "Farming sim"

# Descargar stopwords en inglés
nltk.download('stopwords')
english_stopwords = set(stopwords.words('english'))

# Agregar las palabras específicas a las stopwords
custom_stopwords = {'game', 'really', 'play', 'like', 'thing', 'would', 'get', 'one', 'even', 'good', 'want', "I'm", 'much', 'make', 'still'}
all_stopwords = english_stopwords.union(custom_stopwords)

df_jrpg = df_games[df_games['tags'].str.contains('Farming Sim', na=False)]
id_jrpgs = df_jrpg['app_id']

df_steam_reviews_english = df_steam_reviews[(df_steam_reviews['language'] == 'english') & (df_steam_reviews['app_id'].isin(id_jrpgs))]

def create_word_cloud(reviews, title, max_words, stopwords):

    # Remover palabras vacías que no agregan nada al gráfico
    def remove_stopwords(text):
        words = text.split()
        filtered_words = [word for word in words if word.lower() not in stopwords]
        return ' '.join(filtered_words)

    cleaned_reviews = [remove_stopwords(review) for review in reviews]

    text = ' '.join(cleaned_reviews)

    wordcloud = WordCloud(width=800, height=400, max_words=max_words, background_color='white', stopwords=stopwords).generate(text)
    plt.figure(figsize=(8, 4))
    plt.imshow(wordcloud, interpolation='bilinear')
    plt.title(title + ' Word Cloud')
    plt.axis('off')
    plt.show()

positive_reviews = df_steam_reviews_english[df_steam_reviews_english['recommended'] == True]['review'].astype(str).sample(n=1000).tolist()
negative_reviews = df_steam_reviews_english[df_steam_reviews_english['recommended'] == False]['review'].astype(str).sample(n=1000).tolist()

create_word_cloud(positive_reviews, 'Reviews positivas para Farming simulator', 1000, all_stopwords)
create_word_cloud(negative_reviews, 'Reviews negativas para Farming simulator', 1000, all_stopwords)

[nltk_data] Downloading package stopwords to /root/nltk_data...
[nltk_data]   Unzipping corpora/stopwords.zip.

from sklearn.metrics import f1_score, recall_score, precision_score
from sklearn.model_selection import train_test_split
import numpy as np

def run_classifier(clf, X, y, num_tests=100):
    metrics = {'precision': [], 'recall': [], 'f1-score': []}

    for _ in range(num_tests):
        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=.30, random_state=15, stratify=y)

        clf.fit(X_train, y_train)
        predictions = clf.predict(X_test)

        metrics['precision'].append(precision_score(y_test, predictions,average='weighted', zero_division=0))
        metrics['recall'].append(recall_score(y_test, predictions, average='weighted', zero_division=0))
        metrics['f1-score'].append(f1_score(y_test, predictions, average='weighted', zero_division=0))
    return metrics

from sklearn.dummy import DummyClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.naive_bayes import GaussianNB  # naive bayes
from sklearn.neighbors import KNeighborsClassifier #kNN
from sklearn.svm import SVC  # support vector machine

c0 = ("Base Dummy", DummyClassifier(strategy='stratified'))
c1 = ("Decision Tree", DecisionTreeClassifier(max_depth=5))
c2 = ("Gaussian Naive Bayes", GaussianNB())
c3 = ("KNN", KNeighborsClassifier(n_neighbors=10))
#c4 = ("Support Vector Machines", SVC())

classifiers = [c0, c1, c2, c3]

class_counts = df_games['estimated_owners'].value_counts()
valid_classes = class_counts[class_counts >= 2].index
data_filtered = df_games[df_games['estimated_owners'].isin(valid_classes)]

#separando atributos predictivos (X) del atributo objetivo (y)
X = data_filtered[['price','metacritic_score']].values
y = data_filtered['estimated_owners'].values

results = {}
for name, clf in classifiers:
    metrics = run_classifier(clf, X, y)   # hay que implementarla en el bloque anterior.
    results[name] = metrics
    print("----------------")
    print("Resultados para clasificador: ", name)
    print("Precision promedio:", np.array(metrics['precision']).mean())
    print("Recall promedio:", np.array(metrics['recall']).mean())
    print("F1-score promedio:", np.array(metrics['f1-score']).mean())
    print("----------------\n\n")

----------------
Resultados para clasificador:  Base Dummy
Precision promedio: 0.45302464994112585
Recall promedio: 0.45279264082849524
F1-score promedio: 0.4529029216032853
----------------


----------------
Resultados para clasificador:  Decision Tree
Precision promedio: 0.6047336565639093
Recall promedio: 0.7040640200847325
F1-score promedio: 0.6394325825118907
----------------


----------------
Resultados para clasificador:  Gaussian Naive Bayes
Precision promedio: 0.5723978257617705
Recall promedio: 0.5142397614938021
F1-score promedio: 0.5001481621798194
----------------


----------------
Resultados para clasificador:  KNN
Precision promedio: 0.6050389965558003
Recall promedio: 0.7016318845127886
F1-score promedio: 0.635961224535507
----------------

from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import train_test_split
import numpy as np
from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay

# Filtramos las clases válidas
class_counts = df_games['estimated_owners'].value_counts()
valid_classes = class_counts[class_counts >= 2].index
data_filtered = df_games[df_games['estimated_owners'].isin(valid_classes)]

# Separando atributos predictivos (X) del atributo objetivo (y)
X = data_filtered[['price', 'metacritic_score']].values
y = data_filtered['estimated_owners'].values

clf = DecisionTreeClassifier(max_depth=5)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.30, random_state=15, stratify=y)
clf.fit(X_train, y_train)
y_pred = clf.predict(X_test)

classes = unique_labels(y_test, y_pred)
conf_matrix = confusion_matrix(y_test, y_pred, labels=classes)
display = ConfusionMatrixDisplay(conf_matrix, display_labels=classes)

# Crear la figura y el eje para la matriz de confusión
fig, ax = plt.subplots(figsize=(9, 8))
display.plot(ax=ax)

# Rotar las etiquetas del eje x
plt.setp(ax.get_xticklabels(), rotation=45, ha="right", rotation_mode="anchor")


# Mostrar el gráfico
plt.show()

class_counts = df_games['estimated_owners'].value_counts()
valid_classes = class_counts[class_counts >= 2].index
data_filtered = df_games[df_games['estimated_owners'].isin(valid_classes)]

X1 = data_filtered[['price','positive']].values
y1 = data_filtered['estimated_owners'].values

results1 = {}
for name, clf in classifiers:
    metrics = run_classifier(clf, X1, y1)   # hay que implementarla en el bloque anterior.
    results1[name] = metrics
    print("----------------")
    print("Resultados para clasificador: ", name)
    print("Precision promedio:", np.array(metrics['precision']).mean())
    print("Recall promedio:", np.array(metrics['recall']).mean())
    print("F1-score promedio:", np.array(metrics['f1-score']).mean())
    print("----------------\n\n")

----------------
Resultados para clasificador:  Base Dummy
Precision promedio: 0.45287710098476075
Recall promedio: 0.4529111093676448
F1-score promedio: 0.45288907260828687
----------------


----------------
Resultados para clasificador:  Decision Tree
Precision promedio: 0.7497584274632675
Recall promedio: 0.7819708143731368
F1-score promedio: 0.7573347346223646
----------------


----------------
Resultados para clasificador:  Gaussian Naive Bayes
Precision promedio: 0.2627310747470592
Recall promedio: 0.24435116899419415
F1-score promedio: 0.1579333562389433
----------------


----------------
Resultados para clasificador:  KNN
Precision promedio: 0.7366627779636193
Recall promedio: 0.7740467597677704
F1-score promedio: 0.7487414539848498
----------------

class_counts = df_games['estimated_owners'].value_counts()
valid_classes = class_counts[class_counts >= 2].index
data_filtered = df_games[df_games['estimated_owners'].isin(valid_classes)]

X1 = data_filtered[['price','positive']].values
y1 = data_filtered['estimated_owners'].values

clf = DecisionTreeClassifier(max_depth=5)
X_train, X_test, y_train, y_test = train_test_split(X1, y1, test_size=0.30, random_state=15, stratify=y1)
clf.fit(X_train, y_train)
y_pred = clf.predict(X_test)

classes = unique_labels(y_test, y_pred)
conf_matrix = confusion_matrix(y_test, y_pred, labels=classes)
display = ConfusionMatrixDisplay(conf_matrix, display_labels=classes)

# Crear la figura y el eje para la matriz de confusión
fig, ax = plt.subplots(figsize=(9, 8))
display.plot(ax=ax)

# Rotar las etiquetas del eje x
plt.setp(ax.get_xticklabels(), rotation=45, ha="right", rotation_mode="anchor")


# Mostrar el gráfico
plt.show()

# Hacemos una copia del DataFrame original
df_games_copy = df_games.copy()

# Convertimos la columna release_date a datetime
df_games_copy['release_date'] = pd.to_datetime(df_games_copy['release_date'], errors='coerce')

# Extraemos características numéricas de la fecha
df_games_copy['year'] = df_games_copy['release_date'].dt.year
df_games_copy['month'] = df_games_copy['release_date'].dt.month
df_games_copy['day'] = df_games_copy['release_date'].dt.day

# Filtramos las clases válidas
class_counts = df_games_copy['estimated_owners'].value_counts()
valid_classes = class_counts[class_counts >= 2].index
data_filtered = df_games_copy[df_games_copy['estimated_owners'].isin(valid_classes)]

# Eliminamos las filas con NaN en las características seleccionadas
data_filtered = data_filtered.dropna(subset=['year', 'month', 'day', 'recommendations'])

# Preparamos las características y la variable objetivo
X2 = data_filtered[['year', 'month', 'day', 'recommendations']].values
y2 = data_filtered['estimated_owners'].values

results2 = {}
for name, clf in classifiers:
    metrics = run_classifier(clf, X2, y2)   # hay que implementarla en el bloque anterior.
    results2[name] = metrics
    print("----------------")
    print("Resultados para clasificador: ", name)
    print("Precision promedio:", np.array(metrics['precision']).mean())
    print("Recall promedio:", np.array(metrics['recall']).mean())
    print("F1-score promedio:", np.array(metrics['f1-score']).mean())
    print("----------------\n\n")

----------------
Resultados para clasificador:  Base Dummy
Precision promedio: 0.4531800334376483
Recall promedio: 0.45346147811077975
F1-score promedio: 0.45331547563076335
----------------


----------------
Resultados para clasificador:  Decision Tree
Precision promedio: 0.616086940999507
Recall promedio: 0.6820178879648516
F1-score promedio: 0.6055770806871238
----------------


----------------
Resultados para clasificador:  Gaussian Naive Bayes
Precision promedio: 0.12177468346275867
Recall promedio: 0.2011611485956379
F1-score promedio: 0.09135724986895451
----------------


----------------
Resultados para clasificador:  KNN
Precision promedio: 0.6166905569975587
Recall promedio: 0.6709948219049114
F1-score promedio: 0.62973466092412
----------------

# Hacemos una copia del DataFrame original
df_games_copy = df_games.copy()

# Convertimos la columna release_date a datetime
df_games_copy['release_date'] = pd.to_datetime(df_games_copy['release_date'], errors='coerce')

# Extraemos características numéricas de la fecha
df_games_copy['year'] = df_games_copy['release_date'].dt.year
df_games_copy['month'] = df_games_copy['release_date'].dt.month
df_games_copy['day'] = df_games_copy['release_date'].dt.day

# Filtramos las clases válidas
class_counts = df_games_copy['estimated_owners'].value_counts()
valid_classes = class_counts[class_counts >= 2].index
data_filtered = df_games_copy[df_games_copy['estimated_owners'].isin(valid_classes)]

# Eliminamos las filas con NaN en las características seleccionadas
data_filtered = data_filtered.dropna(subset=['year', 'month', 'day', 'recommendations'])

# Preparamos las características y la variable objetivo
X2 = data_filtered[['year', 'month', 'day', 'recommendations']].values
y2 = data_filtered['estimated_owners'].values

clf = DecisionTreeClassifier(max_depth=5)
X_train, X_test, y_train, y_test = train_test_split(X2, y2, test_size=0.30, random_state=15, stratify=y2)
clf.fit(X_train, y_train)
y_pred = clf.predict(X_test)

classes = unique_labels(y_test, y_pred)
conf_matrix = confusion_matrix(y_test, y_pred, labels=classes)
display = ConfusionMatrixDisplay(conf_matrix, display_labels=classes)

# Crear la figura y el eje para la matriz de confusión
fig, ax = plt.subplots(figsize=(9, 8))
display.plot(ax=ax)

# Rotar las etiquetas del eje x
plt.setp(ax.get_xticklabels(), rotation=45, ha="right", rotation_mode="anchor")


# Mostrar el gráfico
plt.show()

class_counts = df_games['estimated_owners'].value_counts()
valid_classes = class_counts[class_counts >= 2].index
data_filtered = df_games[df_games['estimated_owners'].isin(valid_classes)]

X3 = data_filtered[['positive','negative']].values
y3 = data_filtered['estimated_owners'].values

results3 = {}
for name, clf in classifiers:
    metrics = run_classifier(clf, X3, y3)   # hay que implementarla en el bloque anterior.
    results3[name] = metrics
    print("----------------")
    print("Resultados para clasificador: ", name)
    print("Precision promedio:", np.array(metrics['precision']).mean())
    print("Recall promedio:", np.array(metrics['recall']).mean())
    print("F1-score promedio:", np.array(metrics['f1-score']).mean())
    print("----------------\n\n")

----------------
Resultados para clasificador:  Base Dummy
Precision promedio: 0.45285587058387755
Recall promedio: 0.4527251686803704
F1-score promedio: 0.4527860122528192
----------------


----------------
Resultados para clasificador:  Decision Tree
Precision promedio: 0.7029434610039946
Recall promedio: 0.7033971442021025
F1-score promedio: 0.68788219727119
----------------


----------------
Resultados para clasificador:  Gaussian Naive Bayes
Precision promedio: 0.10356141353952113
Recall promedio: 0.2256786442805586
F1-score promedio: 0.1153237190476415
----------------


----------------
Resultados para clasificador:  KNN
Precision promedio: 0.6975135052229418
Recall promedio: 0.6999450808096661
F1-score promedio: 0.6850103852704434
----------------

class_counts = df_games['estimated_owners'].value_counts()
valid_classes = class_counts[class_counts >= 2].index
data_filtered = df_games[df_games['estimated_owners'].isin(valid_classes)]

X3 = data_filtered[['positive','negative']].values
y3 = data_filtered['estimated_owners'].values

clf = DecisionTreeClassifier(max_depth=5)
X_train, X_test, y_train, y_test = train_test_split(X3, y3, test_size=0.30, random_state=15, stratify=y3)
clf.fit(X_train, y_train)
y_pred = clf.predict(X_test)

classes = unique_labels(y_test, y_pred)
conf_matrix = confusion_matrix(y_test, y_pred, labels=classes)
display = ConfusionMatrixDisplay(conf_matrix, display_labels=classes)

# Crear la figura y el eje para la matriz de confusión
fig, ax = plt.subplots(figsize=(9, 8))
display.plot(ax=ax)

# Rotar las etiquetas del eje x
plt.setp(ax.get_xticklabels(), rotation=45, ha="right", rotation_mode="anchor")


# Mostrar el gráfico
plt.show()

Hito 1: Estudio de las recomendaciones de Steam¶

1. Introducción¶

1.1 ¿Qué es Steam?¶

1.2 Motivación¶

2. Exploración de Datos¶

3. Preguntas y problemas¶

Hito 2¶

Pregunta 1 (Clasificadores)¶

¿Qué parámetros influyen más en la cantidad de ventas totales?¶

Pregunta 2 (Regresión)¶

¿Se puede predecir la cantidad de juegos con género "X" que habrán en un año determinado?¶

Pregunta 3 (Clustering)¶

¿Importa la popularidad del género para aumentar las ventas?. Si haces un juego de un género popular: ¿Aseguras tener un mínimo de ventas?, ¿dependes más de las reviews positivas?¶

2. Resultado preliminares¶

Pregunta 1¶

Contribuciones de cada integrante Hito 1¶

Contribuciones de cada integrante Hito 2¶

Anexos¶